package competition;

import java.util.*;

/**
 * @BelongsProject: LeetCode
 * @BelongsPackage: competition
 * @Author: 江岸
 * @CreateTime: 2021-04-18 10:29
 * @Description:
 */
public class Week237 {

    /**
     * 5734. 判断句子是否为全字母句 显示英文描述
     * 全字母句 指包含英语字母表中每个字母至少一次的句子。
     * <p>
     * 给你一个仅由小写英文字母组成的字符串 sentence ，请你判断 sentence 是否为 全字母句 。
     * <p>
     * 如果是，返回 true ；否则，返回 false 。
     */
    public boolean checkIfPangram(String sentence) {
        int[] ints = new int[26];
        int count = 0;
        for (int i = 0; i < sentence.length(); i++) {
            int index = sentence.charAt(i) - 'a';
            if (ints[index] == 0) {
                ints[index] = 1;
                count++;
                if (count == 26) return true;
            }
        }
        return false;
    }

    public int maxIceCream(int[] costs, int coins) {
        Arrays.sort(costs);
        int count = 0;
        for (int i = 0; i < costs.length; i++) {
            if (costs[i] <= coins) {
                count++;
                coins = coins - costs[i];
            }
        }
        return count;
    }

    public static void main(String[] args) {
        int[][] arr = {{100,100},{1000000000,1000000000}};
        //System.out.println(Arrays.toString( getOrder(arr)));


    }

        // 对象化每一个任务，id 就是下标，time 就是开始时间和持续时间
        static class Task {
            int id;
            int[] time;

            Task(int id, int[] time) {
                this.id = id;
                this.time = time;
            }
        }

        //5736. 单线程 CPU
        public int[] getOrder(int[][] tasks) {
            int n = tasks.length;
            Task[] ts = new Task[n];
            // new 出来每一个任务数据结构，方便排序
            for (int i = 0; i < n; ++i) ts[i] = new Task(i, tasks[i]);
            // 按照开始时间递增排好序
            Arrays.sort(ts, Comparator.comparingInt(o -> o.time[0]));
            // 优先级队列，比较器需要【保证首先按照消耗时间从小到大排列，然后保证同样消耗时间的 id 小的排前面】
            PriorityQueue<Task> priorityQueue = new PriorityQueue<>((o1, o2) ->
                    o1.time[1] == o2.time[1] ? o1.id - o2.id : o1.time[1] - o2.time[1]
            );
            // 直接从第一个任务开始的时间开始累加计时
            long T = ts[0].time[0];
            // ans 表示返回值， idx 表示返回值中的下标
            int[] ans = new int[n];
            int idx = 0;
            // 把所有开始时间 time[0] 不超过 T 的任务加到优先级队列里面
            int iter = 0;   // iter 表示将要添加到优先级队列中第几个了
            for (; iter < n; ++iter) {
                // 把所有不超过当前时间 T 的元素都放到优先级队列里面去
                if (ts[iter].time[0] <= T) priorityQueue.offer(ts[iter]);
                    // 如果 iter 指向的任务开始时间已经超过了 T，那么后面的都超过，就跳出来
                else break;
            }

            while (!priorityQueue.isEmpty()) {
                Task task = priorityQueue.poll();
                // 处理完这个任务，时间上要累加，同时往返回值中记录下标
                T += task.time[1];
                ans[idx++] = task.id;
                // 增加空转时间对齐，因为可能出现 [1, 2], [100, 5] 这样的数据，这样前后不接
                if (iter < n && priorityQueue.isEmpty() && T < ts[iter].time[0]) T = ts[iter].time[0];
                for (; iter < n; ++iter) {
                    // 把所有不超过当前时间 T 的元素都放到优先级队列里面去
                    if (ts[iter].time[0] <= T) priorityQueue.offer(ts[iter]);
                        // 如果 iter 指向的任务开始时间已经超过了 T，那么后面的都超过，就跳出来
                    else break;
                }
            }
            return ans;
        }


}
